{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\\\baidu.png\" alt=\"some_text\">\n",
    "<h1> 第二讲 程序设计基础</h1>\n",
    "<a id=backup></a>\n",
    "<H2>目录</H2>  \n",
    "\n",
    "[2.1 程序执行过程](#Section1)  \n",
    "[2.2 程序实例](#Section2)  \n",
    "[2.3 程序的基本结构](#Section3)     \n",
    "[2.4 顺序结构](#Section4)  \n",
    "[2.5 分支结构](#Section5)  \n",
    "[2.6 循环结构](#Section6) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = Section1> </a>\n",
    "## 2.1 程序执行过程\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x16ffc4f5900>,\n",
       " <matplotlib.lines.Line2D at 0x16ffc4f5960>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "x = np.linspace(0,6*np.pi)\n",
    "a=1\n",
    "plt.plot(x,np.sin(x),x,np.cos(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 程序设计语言：机器语言、汇编语言、高级语言\n",
    "## 编译和解释\n",
    "编译：fortran C C++ C#\n",
    "解释：basic JavaScript PHP \n",
    "Python？？？\n",
    "Python语言执行的几种方式：\n",
    "\n",
    "分析程序执行过程-IPO：  \n",
    "a. Input模块：  \n",
    "b. Process模块：  \n",
    "c. Output模块：  \n",
    "\n",
    "\n",
    "\n",
    "[返回](#backup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = Section2> </a>\n",
    "## 2.2 程序实例\n",
    "\n",
    "<p><a href=\"https://yanghailin.blog.csdn.net/article/details/81126087?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-5.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-5.no_search_link\">\n",
    "this is example of python</a></p"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？\n",
    "\n",
    "要素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L=[]\n",
    "a=[1,2,3,4]\n",
    " \n",
    "#for i in range(len(a)):\n",
    " \n",
    "for val_1 in a:   #   for(i=1;i<n;I++)\n",
    "    for val_2 in a:\n",
    "        for val_3 in a:\n",
    "            if(val_1 == val_2 or val_1 == val_3 or val_2 == val_3):\n",
    "                continue;\n",
    "            else:\n",
    "                L.append(str(val_1)+str(val_2)+str(val_3))\n",
    " \n",
    " \n",
    "print(len(L)) \n",
    "print (L)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 n= 1\n",
      "1 2 4 n= 2\n",
      "1 3 2 n= 3\n",
      "1 3 4 n= 4\n",
      "1 4 2 n= 5\n",
      "1 4 3 n= 6\n",
      "2 1 3 n= 7\n",
      "2 1 4 n= 8\n",
      "2 3 1 n= 9\n",
      "2 3 4 n= 10\n",
      "2 4 1 n= 11\n",
      "2 4 3 n= 12\n",
      "3 1 2 n= 13\n",
      "3 1 4 n= 14\n",
      "3 2 1 n= 15\n",
      "3 2 4 n= 16\n",
      "3 4 1 n= 17\n",
      "3 4 2 n= 18\n",
      "4 1 2 n= 19\n",
      "4 1 3 n= 20\n",
      "4 2 1 n= 21\n",
      "4 2 3 n= 22\n",
      "4 3 1 n= 23\n",
      "4 3 2 n= 24\n"
     ]
    }
   ],
   "source": [
    "n=0\n",
    "for i in range(1,5):\n",
    "    for j in range(1,5):\n",
    "        for k in range(1,5):\n",
    "            if( i != k ) and (i != j) and (j != k):\n",
    "                n=n+1\n",
    "                print (i,j,k,\"n=\",n)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "企业发放的奖金根据利润提成。\n",
    "利润(I)低于或等于10万元时，奖金可提10%；\n",
    "利润高于10万元，低于20万元时，低于10万元的部分\n",
    "按10%提成，高于10万元的部分，可提成7.5%；\n",
    "20万到40万之间时，高于20万元的部分，可提成5%；\n",
    "40万到60万之间时高于40万元的部分，可提成3%；\n",
    "60万到100万之间时，高于60万元的部分，可提成1.5%;\n",
    "高于100万元时,超过100万元的部分按1%提成。\n",
    "从键盘输入当月利润I，求应发放奖金总数？\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "profit = 0\n",
    "I = int(input(\"please input: \"))\n",
    "if(I<=10):\n",
    "    profit = 0.1 * I\n",
    "elif(I <= 20):\n",
    "    profit = 10 *0.1 + (I - 10)*0.075\n",
    "elif(I <=40):\n",
    "    profit = 10 * 0.1 + (20 - 10)*0.075 + (I - 20)*0.05\n",
    "elif(I <= 60):\n",
    "    profit = 10 * 0.1 + (20 - 10)*0.075 + (40 - 20)*0.05 + (I - 40)*0.03\n",
    "elif(I <= 100):\n",
    "    profit = 10 * 0.1 + (20 - 10)*0.075 + (40 - 20)*0.05 + (60 - 40)*0.03 + (I - 60)*0.015\n",
    "else : \n",
    "    profit = 10 * 0.1 + (20 - 10)*0.075 + (40 - 20)*0.05 + (60 - 40)*0.03 + (100 - 60)*0.015 + (I -100)*0.01\n",
    "    \n",
    "print (\"profit=\",profit)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = int(input('净利润:'))\n",
    "arr = [1000000,600000,400000,200000,100000,0]\n",
    "rat = [0.01,0.015,0.03,0.05,0.075,0.1]\n",
    "r = 0\n",
    "for idx in range(0,6):\n",
    "    if i>arr[idx]:\n",
    "        r+=(i-arr[idx])*rat[idx]#r=r+nnn\n",
    "        print((i-arr[idx])*rat[idx])\n",
    "        i=arr[idx]\n",
    "print (\"profit=\",r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 数字类型转换\n",
    "有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。\n",
    "\n",
    "int(x) 将x转换为一个整数。\n",
    "\n",
    "float(x) 将x转换到一个浮点数。\n",
    "\n",
    "complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。\n",
    "\n",
    "complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Section3></a>\n",
    "## 2.3程序的基本结构\n",
    "结构化程序的三大基本结构：\n",
    "\n",
    "a.顺序结构  \n",
    "b.分支结构  \n",
    "c.循环结构  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "[返回](#backup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Section4></a>\n",
    "## 2.4顺序结构\n",
    "\n",
    "### 数学函数\n",
    "<table><tr>\n",
    "<th>函数</th><th>返回值 ( 描述 )</th></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-abs.html\" rel=\"noopener noreferrer\">abs(x)</a></td><td>返回数字的绝对值，如abs(-10) 返回 10</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-ceil.html\" rel=\"noopener noreferrer\">ceil(x) </a></td><td>返回数字的上入整数，如math.ceil(4.1) 返回 5</td></tr>\n",
    "<tr><td><p>cmp(x, y)</p></td>\n",
    "<td>如果 x &lt; y 返回 -1, 如果 x == y 返回 0, 如果 x &gt; y 返回 1。 <strong style=\"color:red\">Python 3 已废弃，使用 (x&gt;y)-(x&lt;y) 替换</strong>。 </td>\n",
    "</tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-exp.html\" rel=\"noopener noreferrer\">exp(x) </a></td><td>返回e的x次幂(e<sup>x</sup>),如math.exp(1) 返回2.718281828459045</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-fabs.html\" rel=\"noopener noreferrer\">fabs(x)</a></td><td>返回数字的绝对值，如math.fabs(-10) 返回10.0</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-floor.html\" rel=\"noopener noreferrer\">floor(x) </a></td><td>返回数字的下舍整数，如math.floor(4.9)返回 4</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-log.html\" rel=\"noopener noreferrer\">log(x) </a></td><td>如math.log(math.e)返回1.0,math.log(100,10)返回2.0</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-log10.html\" rel=\"noopener noreferrer\">log10(x) </a></td><td>返回以10为基数的x的对数，如math.log10(100)返回 2.0</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-max.html\" rel=\"noopener noreferrer\">max(x1, x2,...) </a></td><td>返回给定参数的最大值，参数可以为序列。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-min.html\" rel=\"noopener noreferrer\">min(x1, x2,...) </a></td><td>返回给定参数的最小值，参数可以为序列。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-modf.html\" rel=\"noopener noreferrer\">modf(x) </a></td><td>返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-pow.html\" rel=\"noopener noreferrer\">pow(x, y)</a></td><td> x**y 运算后的值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-round.html\" rel=\"noopener noreferrer\">round(x [,n])</a></td><td><p>返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。</p>\n",
    "<p><strong>其实准确的说是保留值将保留到离上一位更近的一端。</strong></p>\n",
    "</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-sqrt.html\" rel=\"noopener noreferrer\">sqrt(x) </a></td><td>返回数字x的平方根。</td></tr>\n",
    "</table>\n",
    "\n",
    "### 随机数函数\n",
    "随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。\n",
    "\n",
    "Python包含以下常用随机数函数：\n",
    "\n",
    "<table><tr>\n",
    "<th>函数</th><th>描述</th></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-choice.html\" rel=\"noopener noreferrer\">choice(seq)</a></td><td>从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-randrange.html\" rel=\"noopener noreferrer\">randrange ([start,] stop [,step]) </a></td><td>从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-random.html\" rel=\"noopener noreferrer\">random() </a></td><td> 随机生成下一个实数，它在[0,1)范围内。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-seed.html\" rel=\"noopener noreferrer\">seed([x]) </a></td><td>改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-shuffle.html\" rel=\"noopener noreferrer\">shuffle(lst) </a></td><td>将序列的所有元素随机排序</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-uniform.html\" rel=\"noopener noreferrer\">uniform(x, y)</a></td><td>随机生成下一个实数，它在[x,y]范围内。</td></tr>\n",
    "</table>\n",
    "\n",
    "### 三角函数\n",
    "Python包括以下三角函数：\n",
    "<table><tr>\n",
    "<th>函数</th><th>描述</th></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-acos.html\" rel=\"noopener noreferrer\">acos(x)</a></td><td>返回x的反余弦弧度值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-asin.html\" rel=\"noopener noreferrer\">asin(x)</a></td><td>返回x的反正弦弧度值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-atan.html\" rel=\"noopener noreferrer\">atan(x)</a></td><td>返回x的反正切弧度值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-atan2.html\" rel=\"noopener noreferrer\">atan2(y, x)</a></td><td>返回给定的 X 及 Y 坐标值的反正切值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-cos.html\" rel=\"noopener noreferrer\">cos(x)</a></td><td>返回x的弧度的余弦值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-hypot.html\" rel=\"noopener noreferrer\">hypot(x, y)</a></td><td>返回欧几里德范数 sqrt(x*x + y*y)。 </td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-sin.html\" rel=\"noopener noreferrer\">sin(x)</a></td><td>返回的x弧度的正弦值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-tan.html\" rel=\"noopener noreferrer\">tan(x)</a></td><td>返回x弧度的正切值。</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-degrees.html\" rel=\"noopener noreferrer\">degrees(x)</a></td><td>将弧度转换为角度,如degrees(math.pi/2) ，  返回90.0</td></tr>\n",
    "<tr><td><a target=\"_blank\" href=\"/python3/python3-func-number-radians.html\" rel=\"noopener noreferrer\">radians(x)</a></td><td>将角度转换为弧度</td></tr>\n",
    "</table>\n",
    "\n",
    "### 数学常量\n",
    "\n",
    "<table><tr>\n",
    "<th>常量</th><th>描述</th></tr>\n",
    "<tr><td>pi</td><td>数学常量 pi（圆周率，一般以π来表示）</td></tr>\n",
    "<tr><td>e</td><td>数学常量 e，e即自然常数（自然常数）。</td></tr>\n",
    "</table>\n",
    "\n",
    "[返回](#backup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "绘制计算圆周长的流程图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import graphviz\n",
    "dot=graphviz.Digraph(comment='the round table',name=\"顺序结构\",node_attr={'shape': 'box'})\n",
    "dot.node('1','Start')\n",
    "dot.node('2','input Radius =?',shape='parallelogram')\n",
    "dot.node('3','Print Radius')\n",
    "dot.node('4','Caculating Area')\n",
    "dot.node('5','Caculating perimeter')\n",
    "dot.node('6','print')\n",
    "dot.node('7','end')\n",
    "dot.edges(['12','23','34','45','56','67'])\n",
    "dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Radius = eval(input(\"请输入圆半径:\"))\n",
    "print(\"Ridus=\",Radius)\n",
    "Area = 3.1415*Radius*Radius\n",
    "perimeter  = 2*3.1415*Radius \n",
    "print(\"面积和周长:\",Area,perimeter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=section4></a>\n",
    "## 2.5分支结构\n",
    "### 2.5.1 Python比较运算符\n",
    "\n",
    "以下假设变量a为10，变量b为20：\n",
    "<table><tr>\n",
    "<th width=\"10%\">运算符</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td><td> 等于 - 比较对象是否相等</td><td> (a == b) 返回 False。 </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td><td> 不等于 - 比较两个对象是否不相等</td><td> (a != b) 返回 True。 </td>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "<td>&gt;</td><td> 大于 - 返回x是否大于y</td><td> (a &gt; b) 返回 False。</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td><td> 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。</td><td> (a &lt; b) 返回 True。 </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;=</td><td> 大于等于 - 返回x是否大于等于y。</td><td> (a &gt;= b) 返回 False。</td>\n",
    "\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;=</td><td> 小于等于 - 返回x是否小于等于y。</td><td> (a &lt;= b) 返回 True。 </td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "### 2.5.2 Python逻辑运算符        \n",
    "Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:\n",
    "<table><tr>\n",
    "<th>运算符</th><th>逻辑表达式</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>and</td><td>x and y</td><td> 布尔\"与\" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。  </td><td> (a and b) 返回 20。</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>or</td><td>x or y</td><td>布尔\"或\" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。</td><td> (a or b) 返回 10。</td>\n",
    "</tr>\n",
    "<tr><td>not</td><td>not x</td><td>布尔\"非\" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td><td> not(a and b) 返回 False </td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "[返回](#backup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.3 条件控制语句\n",
    "Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。\n",
    "\n",
    "可以通过下图来简单了解条件语句的执行过程:\n",
    "\n",
    "<img src=\".//img//if-condition.jpg\" width=\"250\"></img>\n",
    "\n",
    "<img src=\".//img//python-if.webp\" width=\"150\"></img>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例题 求绝对值。\n",
    "\n",
    "输入：x\n",
    "$$\n",
    "\\begin{align}\n",
    "&&\\left|y\\right |= \\left\\{\\begin{matrix}\n",
    "x & if \\: x\\geq 0\\\\-x& if \\:x< 0\n",
    "\\end{matrix}\\right.{\\color{Red} }\n",
    "\\end{align}\n",
    "$$\n",
    "输出：y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import graphviz\n",
    "dot=graphviz.Digraph(comment='the round table',name=\"分支结构\",node_attr={'shape': 'box'})\n",
    "dot.node('1','开始')\n",
    "dot.node('2','输入Real Number =?',shape='parallelogram')\n",
    "dot.node('3','判断RealNumber是否大于0？',shape='diamond')\n",
    "dot.node('4','RealNumber=RealNumber')\n",
    "dot.node('5','RealNumber=-RealNumber')\n",
    "dot.node('6','输出绝对值',shape='parallelogram')\n",
    "dot.node('7','结束')\n",
    "dot.edges(['12','23','34','35','46','56','67'])\n",
    "dot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求绝对值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "RealNumber = eval(input(\"输入实数:\"))\n",
    "\n",
    "if (RealNumber < 0):\n",
    "    RealNumber = -RealNumber\n",
    "print(\"绝对值:\",RealNumber)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=section6></a>\n",
    "## 2.6循环结构\n",
    "\n",
    "循环结构：\n",
    "\n",
    "---while语句\n",
    "\n",
    "---for语句\n",
    "\n",
    "循环分类：  \n",
    "--- 当型循环  \n",
    "--- 直到型循环  \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "[返回](#backup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "char1 =\"a\"\n",
    "char2=\"b\"\n",
    "char3=\"c\"\n",
    "char=char1+char2+char3\n",
    "boor1=(char[2]==char3)\n",
    "print(boor1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例题 整数累加：  \n",
    "输入：正整数R    \n",
    "处理：  \n",
    "S=1+2+3+…+R  \n",
    "<img src=\"./img/int_add.png\" width=\"150\">  \n",
    "输出：输出S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = eval(input(\"请输入正整数:\"))\n",
    "i, S = 0, 0\n",
    "while (i<=R):\n",
    "    S = S + i\n",
    "    i = i + 1\n",
    "print(\"累加求和\",S)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 提供了 for 循环和 while 循环（在 Python 中没有 do..while 循环）:\n",
    "\n",
    "<table><tr><th style=\"width:30%\">循环类型</th><th>描述</th></tr>\n",
    "<tr><td><a href=\"/python/python-while-loop.html\" title=\"Python WHILE 循环\">while 循环</a></td><td>在给定的判断条件为 true 时执行循环体，否则退出循环体。</td></tr>\n",
    "<tr><td><a href=\"/python/python-for-loop.html\" title=\" Python FOR 循环\">for 循环</a></td><td>重复执行语句</td></tr>\n",
    "<tr><td><a href=\"/python/python-nested-loops.html\" title=\"Python 循环全套\">嵌套循环</a></td><td>你可以在while循环体中嵌套for循环</td></tr>\n",
    "</table>\n",
    "\n",
    "### 循环控制语句\n",
    "循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：\n",
    "<table><tr><th style=\"width:30%\">控制语句</th><th>描述</th></tr>\n",
    "<tr><td><a href=\"/python/python-break-statement.html\" title=\"Python break 语句\">break 语句</a></td><td>在语句块执行过程中终止循环，并且跳出整个循环</td></tr>\n",
    "<tr><td><a href=\"/python/python-continue-statement.html\" title=\"Python  语句\">continue 语句</a></td><td>在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。</td></tr>\n",
    "<tr><td><a href=\"/python/python-pass-statement.html\" title=\"Python pass 语句\">pass 语句</a></td><td>pass是空语句，是为了保持程序结构的完整性。</td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例题 绘制数字图画\n",
    "   <img src=\".//img//jqm1.jpg\" width=\"150 \" alt=\"机器猫\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "show_heigth = 50\n",
    "show_width = 110\n",
    "#这两个数字是调出来的\n",
    "\n",
    "ascii_char = list(\n",
    "    \"$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\\|()1{}[]?-_+~<>i!lI;:,\\\"^`'. \")\n",
    "#生成一个ascii字符列表\n",
    "char_len = len(ascii_char)\n",
    "\n",
    "pic = plt.imread(\"..\\\\jqm1.jpg\")\n",
    "#使用plt.imread方法来读取图像，对于彩图，返回size = heigth*width*3的图像\n",
    "#matplotlib 中色彩排列是R G B\n",
    "#opencv的cv2中色彩排列是B G R\n",
    "\n",
    "pic_heigth, pic_width, _ = pic.shape\n",
    "#获取图像的高、宽\n",
    "\n",
    "gray = 0.2126 * pic[:, :, 0] + 0.7152 * pic[:, :, 1] + 0.0722 * pic[:, :, 2]\n",
    "#RGB转灰度图的公式 gray = 0.2126 * r + 0.7152 * g + 0.0722 * b\n",
    "\n",
    "#思路就是根据灰度值，映射到相应的ascii_char\n",
    "for i in range(show_heigth):\n",
    "    #根据比例映射到对应的像素\n",
    "    y = int(i * pic_heigth / show_heigth)\n",
    "    text = \"\"\n",
    "    for j in range(show_width):\n",
    "        x = int(j * pic_width / show_width)\n",
    "        text += ascii_char[int(gray[y][x] / 256 * char_len)]\n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ! pip install -i http源\n",
    "新版ubuntu要求使用https源，要注意。\n",
    "\n",
    "清华：https://pypi.tuna.tsinghua.edu.cn/simple\n",
    "\n",
    "阿里云：https://mirrors.aliyun.com/pypi/simple/\n",
    "\n",
    "中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/\n",
    "\n",
    "华中理工大学：https://pypi.hustunique.com/\n",
    "\n",
    "山东理工大学：https://pypi.sdutlinux.org/ \n",
    "\n",
    "豆瓣：https://pypi.douban.com/simple/\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('python310')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a888cd810c90be07c3c921372a6d7ff433f5a38d5779dfb2a871d99db75673fb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
